package com.example.aigc_education.controller;

import com.example.aigc_education.domain.*;
import com.example.aigc_education.domain.dto.ModifyByAdminDTO;
import com.example.aigc_education.domain.dto.SelectByConditionDTO;
import com.example.aigc_education.domain.dto.UpdateExamByAdminDTO;
import com.example.aigc_education.domain.po.SelectAnswerByAdminPO;
import com.example.aigc_education.service.ChecklistService;
import com.example.aigc_education.service.DaysMatterService;
import com.example.aigc_education.service.UserService;
import com.example.aigc_education.service.impl.*;
import com.example.aigc_education.utils.ResultUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/admin")
public class AdminController {
    @Resource
    private UserService userService;
    @Resource
    private UserCourseServiceImpl userCourseService;

    @Resource
    private ExamServiceImpl examService;

    @Resource
    private CourseServiceImpl courseService;

    @Resource
    private AnswerServiceImpl answerService;

    @Resource
    private PaperServiceImpl paperService;

    @Resource
    private PlanServiceImpl planService;

    @Resource
    private QuestionServiceImpl questionService;

    @Resource
    private TodoServiceImpl todoService;

    @Resource
    private ChecklistService checkListService;

    @Autowired
    private DaysMatterService daysMatterService;
    /**
     * 添加用户
     * 需要sys:add:user权限
     * @param user 请求体中包含的用户信息
     * @return 返回操作结果，成功则返回包含成功消息的结果对象，失败则返回包含错误消息的结果对象
     */
    @PostMapping("/addUser")
    @PreAuthorize("hasAuthority('sys:add:user')")
    public ResultUtil addUser(@RequestBody User user) {
        Boolean is_add = userService.addUser(user);
        // 判断用户添加操作是否成功
        if (is_add){
            return ResultUtil.success("用户添加成功");
        }else {
            return ResultUtil.error("用户添加失败");
        }
    }

    /**
     * 通过管理员修改用户信息
     *
     * @param modifyByAdminDto 包含需要修改的用户信息的Dto对象
     * @return 如果用户信息修改成功，返回成功的提示信息；如果修改失败，返回失败的提示信息。
     * {@code @PostMapping("/updateInfoByAdmin")} 注解指明该方法处理来自URL /updateInfoByAdmin 的POST请求。
     * {@code @PreAuthorize("hasAuthority('sys:update:user')")} 注解用于权限检查，确保只有拥有 sys:update:user 权限的用户可以调用此方法。
     */
    @PostMapping("/updateInfo")
    @PreAuthorize("hasAuthority('sys:update:user')")
    public ResultUtil updateInfoByAdmin(@RequestBody ModifyByAdminDTO modifyByAdminDto) {
        // 调用userService的updateInfoByAdmin方法尝试更新用户信息
        Boolean is_update = userService.updateInfoByAdmin(modifyByAdminDto);
        // 根据updateInfoByAdmin方法的返回值决定返回成功还是失败的结果
        if (is_update){
            return ResultUtil.success("用户信息修改成功");
        }else {
            return ResultUtil.error("用户信息修改失败");
        }
    }
    /**
     * 通过GET请求获取所有用户信息
     *
     * 此方法使用了Spring MVC的@GetMapping注解，指定对应的请求方法为GET，并定义了请求的URL路径为/showAllUser。
     * 同时，使用了Spring Security的@PreAuthorize注解，指定了访问该方法需要具备'sys:user:list'权限。
     *
     * @return ResultUtil 对象，包含操作结果和用户信息。如果操作成功，用户信息将包含在ResultUtil的成功响应中。
     */
    @GetMapping("/showAllUser")
    @PreAuthorize("hasAuthority('sys:user:list')")
    public ResultUtil showAllUser(){
        // 调用userService的getAllUser方法获取所有用户信息，并使用ResultUtil的成功方法返回这些信息。
        return ResultUtil.success(userService.getAllUser());
    }

    /**
     * 根据条件展示用户信息
     * 该方法通过接收前端发送的查询条件，调用userService的getUserByCondition方法获取符合条件的用户列表，
     * 并将结果封装在ResultUtil中返回给前端。
     *
     * @param selectByConditionDto 包含用户查询条件的DTO对象，由前端发送。
     * @return ResultUtil 包含查询结果的工具类对象，成功时返回用户列表，失败时包含错误信息。
     */
    @PostMapping("/showUserByCondition")
    @PreAuthorize("hasAuthority('sys:user:list')")
    public ResultUtil showUserByCondition(@RequestBody SelectByConditionDTO selectByConditionDto){
        return ResultUtil.success(userService.getUserByCondition(selectByConditionDto));
    }


    /**
     * 通过GET请求获取所有课程信息的接口
     *
     * 该接口使用了Spring MVC的@GetMapping注解，指定了请求的URL为"/getAllCourse"。
     * 它同时使用了Spring Security的@PreAuthorize注解，确保只有拥有"sys:course:list"权限的用户才能访问。
     *
     * @return ResultUtil 对象，包含操作结果和所有课程的信息。如果操作成功，课程信息将作为数据部分返回。
     */
    @GetMapping("/getAllCourse")
    @PreAuthorize("hasAuthority('sys:course:list')")
    public ResultUtil getAllCourse(){
        // 调用userService的selectAllCourse方法获取所有课程信息，并将结果包装在ResultUtil对象中返回
        return ResultUtil.success(userCourseService.selectAllCourse());
    }

    /**
     * 通过GET请求获取所有学生考试成绩的信息
     *
     * 此方法使用了Spring MVC的@GetMapping注解，指定了请求的URL路径为"/getAllGrades"。
     * 它同时使用了Spring Security的@PreAuthorize注解，确保只有拥有"sys:grades:list"权限的用户才能访问此方法。
     *
     * @return ResultUtil 对象，包含所有考试成绩的信息。如果查询成功，ResultUtil的状态码为200，数据部分为所有的考试成绩；
     *         如果出现异常，状态码和消息会相应地反映异常情况。
     */
    @GetMapping("/getAllGrades")
    @PreAuthorize("hasAuthority('sys:grades:list')")
    public ResultUtil getAllGrades(){
        // 调用examService的selectAllExam方法查询所有考试成绩，并将结果封装到ResultUtil对象中返回
        return ResultUtil.success(examService.selectAllExam());
    }

    /**
     * 管理员更新考试信息
     * 通过管理员身份，使用UpdateExamByAdminDTO对象中的数据更新指定ID的考试信息。
     * 此接口需要具有"sys:update:exam"权限的用户才能访问。
     *
     * @param updateExamByAdminDto 包含更新考试所需信息的数据传输对象。
     * @param examId 要更新的考试的唯一标识符。
     * @return 返回一个表示操作结果的成功消息。
     */
    @PostMapping("/updateExam")
    @PreAuthorize("hasAuthority('sys:update:exam')")
    public ResultUtil updateExam(@RequestBody UpdateExamByAdminDTO updateExamByAdminDto, Long examId) {
        // 调用examService更新指定考试ID的考试信息
        examService.updateExamByExamId(updateExamByAdminDto, examId);
        // 返回一个表示考试信息修改成功的结果对象
        return ResultUtil.success("考试信息修改成功");
    }


    /**
     * 管理员通过考试ID删除考试信息
     *
     * 该接口是一个受保护的接口，只有具备"sys:delete:exam"权限的用户才能访问。
     * 它通过接收一个考试ID（examId），调用examService的deleteExamByExamId方法来删除相应的考试记录。
     * 接口返回一个ResultUtil对象，表示删除操作的成功或失败。
     *
     * @param examId 需要删除的考试的唯一标识符。
     * @return ResultUtil 包含操作结果信息的对象。
     */
    @PostMapping("/deleteExam")
    @PreAuthorize("hasAuthority('sys:delete:exam')")
    public ResultUtil deleteExam(Long examId) {
        // 调用examService的deleteExamByExamId方法删除指定ID的考试信息
        examService.deleteExamByExamId(examId);
        // 返回一个表示考试信息删除成功的结果对象
        return ResultUtil.success("考试信息删除成功");
    }


    /**
     * 管理员添加考试信息
     * 此方法接收一个Exam对象作为请求体，用于新增考试信息。
     * 添加成功后，返回一个包含成功消息的结果对象。
     *
     * @param exam 包含考试信息的实体类对象。
     * @return ResultUtil 结果工具类对象，包含成功消息。
     */
    @PostMapping("/addExam")
    @PreAuthorize("hasAuthority('sys:add:exam')")
    public ResultUtil addExam(@RequestBody Exam exam) {
        // 调用考试服务层方法添加考试信息
        examService.addExam(exam);
        // 返回成功结果，包含提示信息
        return ResultUtil.success("考试信息添加成功");
    }

    /**
     * 管理员删除用户
     *
     * 此方法使用@PreAuthorize注解来限制访问权限，只有具备'sys:delete:user'权限的用户才能执行此操作。
     * 通过传递用户的ID作为参数，调用userService的DeleteById方法来删除用户。
     * 方法返回一个ResultUtil对象，表示操作是否成功，成功时包含成功消息。
     *
     * @param userId 需要删除的用户的ID。
     * @return ResultUtil 对象，包含操作结果的状态和消息。
     */
    @PostMapping("/deleteUser")
    @PreAuthorize("hasAuthority('sys:delete:user')")
    public ResultUtil deleteUser(Long userId) {
        userService.deleteById(userId);
        return ResultUtil.success("用户信息删除成功");
    }

    /**
     * 管理员添加课程
     * 使用@PreAuthorize注解来限制访问权限，只有具备'sys:add:course'权限的用户才能执行此操作。
     * 请求体中包含待添加的课程信息。
     *
     * @param course 待添加的课程对象，包含课程的详细信息。
     * @return 返回一个结果对象，指示课程添加操作是否成功。
     */
    @PostMapping("/addCourse")
    @PreAuthorize("hasAuthority('sys:add:course')")
    public ResultUtil addCourse(@RequestBody Course course) {
        // 调用课程服务层的方法来添加课程
        courseService.addCourse(course);
        // 返回一个表示操作成功的结果对象，包含成功消息。
        return ResultUtil.success("课程添加成功");
    }

    /**
     * 管理员更新课程信息
     * 通过@PreAuthorize注解限制只有具备"sys:update:course"权限的用户才能访问此接口。
     * 使用@PostMapping注解指定此方法处理HTTP POST请求，请求路径为/updateCourseInMongo。
     *
     * @param course 通过@RequestBody注解将HTTP请求体中的数据绑定到Course对象上，包含待更新的课程信息。
     * @param courseId 更新的课程ID，用于精确指定要更新的课程。
     * @return 返回一个ResultUtil对象，其中包含操作结果的信息。如果操作成功，会返回"课程信息修改成功"的提示。
     */
    @PostMapping("/updateCourse")
    @PreAuthorize("hasAuthority('sys:update:course')")
    public ResultUtil updateCourse(@RequestBody Course course, Long courseId) {
        // 调用课程服务层的方法来更新课程信息
        courseService.updateCourse(course, courseId);
        // 返回一个表示操作成功的ResultUtil对象
        return ResultUtil.success("课程信息修改成功");
    }


    /**
     * 管理员删除课程
     * <p>
     * 该接口使用POST请求方法，并通过课程ID删除相应的课程信息。需要具有相应的权限才能访问。
     * 接口调用成功后，会返回一个表示删除成功的结果信息。
     *
     * @param courseId 课程ID，用于指定要删除的课程。
     * @return 返回一个表示删除成功的结果信息。
     */
    @PostMapping("/deleteCourse")
    @PreAuthorize("hasAuthority('sys:delete:course')")
    public ResultUtil deleteCourse(Long courseId) {
        // 调用课程服务，删除指定ID的课程
        courseService.deleteCourse(courseId);
        // 返回成功结果，包含删除成功的提示信息
        return ResultUtil.success("课程信息删除成功");
    }


    /**
     * 管理员获取所有答案的列表
     *
     * 此方法允许具有“sys:answer:list”权限的用户查询系统中所有答案的信息。
     * 它使用了Spring MVC的@GetMapping注解来指定HTTP GET请求的映射路径为“/showAllAnswer”。
     * 同时，利用Spring Security的@PreAuthorize注解来确保只有具备相应权限的用户才能访问该方法。
     *
     * @return ResultUtil 对象，包含操作结果和所有答案的信息。如果操作成功，将返回所有答案的列表；
     *         否则，根据ResultUtil的配置，可能返回错误代码和消息。
     */
    @GetMapping("/showAllAnswer")
    @PreAuthorize("hasAuthority('sys:answer:list')")
    public ResultUtil showAllAnswer(){
        // 调用answerService的selectAllAnswer方法查询所有答案
        List<SelectAnswerByAdminPO> selectAnswerByAdminPOS = answerService.selectAllAnswer();
        // 返回操作结果为成功的ResultUtil对象，并包含所有答案的信息
        return ResultUtil.success(selectAnswerByAdminPOS);
    }

    /**
     * 管理员添加答案。
     *
     * 此方法授权给具有"sys:add:answer"权限的用户使用。
     * 它接收一个Answer对象作为请求体，将该答案添加到系统中。
     *
     * @param answer 待添加的答案对象，包含答案的详细信息。
     * @return ResultUtil 对象，表示操作结果。成功时，包含成功消息。
     */
    @PostMapping("/addAnswer")
    @PreAuthorize("hasAuthority('sys:add:answer')")
    public ResultUtil addAnswer(@RequestBody Answer answer) {
        // 调用answerService的addAnswer方法添加答案
        answerService.addAnswer(answer);
        // 返回操作成功的ResultUtil对象
        return ResultUtil.success("答案添加成功");
    }

    /**
     * 管理员请求更新答案。
     * 使用@PreAuthorize注解来限制只有具备"sys:update:answer"权限的用户才能执行此操作。
     *
     * @param answer 包含新答案内容的实体类。
     * @param answerId 需要更新的答案的ID。
     * @return 返回一个ResultUtil对象，表示操作结果。如果成功，包含成功消息。
     */
    @PostMapping("/updateAnswer")
    @PreAuthorize("hasAuthority('sys:update:answer')")
    public ResultUtil updateAnswer(@RequestBody Answer answer, Long answerId) {
        // 调用answerService的updateAnswer方法来更新答案内容
        // 调用answerService的updateAnswer方法更新答案
        answerService.updateAnswer(answer, answerId);
        // 返回操作成功的提示信息
        // 返回操作成功的ResultUtil对象
        return ResultUtil.success("答案修改成功");
    }


    /**
     * 管理员删除答案。
     * 使用@PreAuthorize注解来限制只有具备"sys:delete:answer"权限���用户才能执行此操作。
     *
     * @param answerId 需要删除的答案的ID。
     * @return 返回一个ResultUtil对象，表示操作结果。如果成功，包含成功消息。
     */
    @PostMapping("/deleteAnswer")
    @PreAuthorize("hasAuthority('sys:delete:answer')")
    public ResultUtil deleteAnswer(Long answerId) {
        // 调用answerService的deleteAnswer方法删除指定ID的答案
        answerService.deleteAnswer(answerId);
        // 返回操作成功的提示信息
        return ResultUtil.success("答案删除成功");
    }


    /**
     * 管理员添加试卷
     *
     * 此方法接收一个Paper对象作为请求体，用于新增试卷信息。
     * 使用@PreAuthorize注解来指定只有具备'sys:add:paper'权限的用户才能执行此操作。
     *
     * @param paper 包含试卷信息的实体类对象。
     * @return 返回一个ResultUtil对象，表示操作结果，成功时包含成功消息。
     */
    @PostMapping("/addPaper")
    @PreAuthorize("hasAuthority('sys:add:paper')")
    public ResultUtil addPaper(@RequestBody Paper paper) {
        // 调用paperService的addPaper方法添加试卷
        paperService.addPaper(paper);
        // 返回操作成功的ResultUtil对象
        return ResultUtil.success("试卷添加成功");
    }


    /**
     * 管理员更新试卷信息
     * 使用@PreAuthorize注解来限制访问权限，只有具备'sys:update:paper'权限的用户才能执行此操作。
     * 请求体中包含待更新的试卷对象。
     *
     * @param paper 包含更新后试卷信息的实体类。
     * @param paperId 需要更新的试卷的ID。
     * @return 返回一个ResultUtil对象，表示操作结果。
     *         如果操作成功，返回包含成功消息的ResultUtil对象。
     */
    @PostMapping("/updatePaper")
    @PreAuthorize("hasAuthority('sys:update:paper')")
    public ResultUtil updatePaper(@RequestBody Paper paper, Long paperId) {
        // 调用paperService的updatePaper方法来更新试卷信息
        paperService.updatePaper(paper, paperId);
        // 返回操作成功的ResultUtil对象
        return ResultUtil.success("试卷修改成功");
    }


    /**
     * 管理员删除试卷
     * 此方法使用@PreAuthorize注解来限制访问权限，只有具备'sys:delete:paper'权限的用户才能执行删除操作。
     * 请求路径为/deletePaper，方法接收一个Long类型的paperId参数，代表要删除的试卷的ID。
     * 调用paperService的deletePaper方法来实际执行删除操作，然后返回一个表示删除成功的结果。
     *
     * @param paperId 需要删除的试卷的ID。
     * @return 返回一个表示删除成功的结果对象，包含成功消息。
     */
    @PostMapping("/deletePaper")
    @PreAuthorize("hasAuthority('sys:delete:paper')")
    public ResultUtil deletePaper(Long paperId) {
        // 调用paperService的deletePaper方法删除指定ID的试卷
        paperService.deletePaper(paperId);
        // 返回操作成功的提示信息
        return ResultUtil.success("试卷删除成功");
    }


    /**
     * 管理员通过试卷ID查询试卷信息
     * 通过调用paperService的selectPaperByPaperId方法，查询指定ID的试卷信息。
     * 该接口需要具备"sys:paper:list"权限才能访问。
     *
     * @return 返回一个ResultUtil对象，包含查询到的试卷信息。
     */
    @GetMapping("/selectPaper")
    @PreAuthorize("hasAuthority('sys:paper:list')")
    public ResultUtil selectPaper() {
        // 调用paperService的selectPaper方法查询所有试卷
        List<Paper> papers = paperService.selectPaper();
        // 返回操作成功的ResultUtil对象，包含查询到的试卷信息
        return ResultUtil.success(papers);
    }



    /**
     * 管理员添加学习计划
     * 通过POST请求向"/addPlan"路径发送请求，以添加新的学习计划。
     * 请求体中应包含待添加的计划对象Plan。
     *
     * @param plan 待添加的学习计划对象，包含计划的详细信息。
     * @return 返回一个结果对象，指示计划添加操作的成功与否，并提供相应的提示信息。
     * @PreAuthorize 注解用于权限控制，确保只有具备"sys:add:plan"权限的用户才能执行此操作。
     */
    @PostMapping("/addPlan")
    @PreAuthorize("hasAuthority('sys:add:plan')")
    public ResultUtil addPlan(@RequestBody Plan plan) {
        // 调用计划服务层的方法，实际添加学习计划。
        planService.addPlan(plan);
        // 返回一个表示操作成功的结果对象，包含成功提示信息。
        return ResultUtil.success("学习计划添加成功");
    }

    /**
     * 管理员更新学习计划
     * @param plan 待更新的学习计划对象，包含新的计划信息。
     * @param planId 需要更新的计划的ID，用于定位特定的计划记录。
     * @return 返回一个表示操作成功的结果对象，包含成功提示信息。
     */
    @PostMapping("/updatePlan")
    @PreAuthorize("hasAuthority('sys:update:plan')")
    public ResultUtil updatePlan(@RequestBody Plan plan, Long planId) {
        // 调用计划服务层的方法，实际更新学习计划。
        planService.updatePlan(plan, planId);
        // 返回一个表示操作成功的结果对象，包含成功提示信息。
        return ResultUtil.success("学习计划修改成功");
    }

    /**
     * 管理员删除学习计划
     * @param planId
     * @return 返回一个表示操作成功的结果对象，包含成功提示信息。
     */
    @PostMapping("/deletePlan")
    @PreAuthorize("hasAuthority('sys:delete:plan')")
    public ResultUtil deletePlan(Long planId) {
        // 调用计划服务层的方法，实际删除学习计划。
        planService.deletePlan(planId);
        // 返回一个表示操作成功的结果对象，包含成功提示信息。
        return ResultUtil.success("学习计划删除成功");
    }

    /**
     * 管理员查询所有学习计划
     * @return 返回一个表示操作成功的结果对象，包含所有学习计划信息。
     */
    @GetMapping("/showAllPlan")
    @PreAuthorize("hasAuthority('sys:plan:list')")
    public ResultUtil showAllPlan() {
        // 调用计划服务层的方法，查询所有学习计划。
        List<Plan> planList = planService.getPlan();
        // 返回一个表示操作成功的结果对象，包含所有学习计划信息。
        return ResultUtil.success(planList);
    }


    /**
     * 管理员添加问题
     *
     * 此方法接收一个Question对象作为请求体，用于新增问题。使用@PreAuthorize注解来限制访问权限，
     * 只有具备'sys:add:question'权限的用户才能执行此操作。返回一个ResultUtil对象，其中包含操作结果的信息。
     *
     * @param question 待添加的问题对象，包含问题的详细信息。
     * @return ResultUtil 成功添加问题后返回包含成功消息的ResultUtil对象。
     */
    @PostMapping("/addQuestion")
    @PreAuthorize("hasAuthority('sys:add:question')")
    public ResultUtil addQuestion(@RequestBody Question question) {
        // 调用questionService的addQuestion方法添加问题
        questionService.addQuestion(question);
        // 返回操作成功的ResultUtil对象
        return ResultUtil.success("问题添加成功");
    }



    /**
     * 管理员更新问题
     *
     * 此方法接收一个包含问题详细信息的Question对象和一个Long类型的questionId参数，
     * 用于指定需要更新的问题。使用@RequestBody注解表明请求体中的数据将被绑定到方法参数上。
     * 使用@PreAuthorize注解来限制访问此方法的权限，只有具备'sys:update:question'权限的用户才能执行更新操作。
     *
     * @param question 包含待更新问题详细信息的Question对象。
     * @param questionId 需要更新的问题的ID。
     * @return 返回一个ResultUtil对象，其中包含操作结果的信息。如果操作成功，会返回"问题修改成功"的提示。
     */
    @PostMapping("/updateQuestion")
    @PreAuthorize("hasAuthority('sys:update:question')")
    public ResultUtil updateQuestion(@RequestBody Question question, Long questionId) {
        // 调用questionService的updateQuestion方法来更新问题
        questionService.updateQuestion(question, questionId);
        // 返回操作成功的ResultUtil对象
        return ResultUtil.success("问题修改成功");
    }


    /**
     * 管理员删除问题
     *
     * 此方法仅允许具有"sys:delete:question"权限的用户调用。
     * 它接收一个Long类型的questionId参数，该参数代表要删除的问题的ID。
     * 方法调用questionService的deleteQuestion方法来执行实际的删除操作。
     * 最后，它返回一个表示删除成功的结果对象。
     *
     * @param questionId 要删除的问题的ID。
     * @return 表示操作结果的ResultUtil对象，包含删除成功的提示信息。
     */
    @PostMapping("/deleteQuestion")
    @PreAuthorize("hasAuthority('sys:delete:question')")
    public ResultUtil deleteQuestion(Long questionId) {
        // 调用questionService的deleteQuestion方法删除指定ID的问题
        questionService.deleteQuestion(questionId);
        // 返回操作成功的提示信息
        return ResultUtil.success("问题删除成功");
    }



    /**
     * 管理员查询所有问题
     *
     * @return ResultUtil 包含操作结果和问题列表的响应对象
     *
     * 本方法通过调用questionService的selectQuestionList方法获取所有问题列表，
     * 并将结果封装在ResultUtil对象中返回。此操作需要具备'sys:question:list'权限。
     */
    @GetMapping("/showAllQuestion")
    @PreAuthorize("hasAuthority('sys:question:list')")
    public ResultUtil showAllQuestion() {
        // 调用questionService的getAllQuestion方法获取所有问题信息
        List<Question> questionList = questionService.selectQuestionList();
        // 返回操作结果为成功的ResultUtil对象，并包含所有问题的信息
        return ResultUtil.success(questionList);
    }



    /**
     * 管理员添加待办事项。
     *
     * 此方法接收一个Todo对象作为请求体，用于新增待办事项。
     * 使用@PreAuthorize注解来指定只有具备'sys:add:todo'权限的用户才能执行此操作。
     *
     * @param todo 待添加的待办事项对象，包含待办事项的详细信息。
     * @return 返回一个ResultUtil对象，表示操作结果。
     *         如果操作成功，会包含一个成功消息。
     */
    @PostMapping("/addTodo")
    @PreAuthorize("hasAuthority('sys:add:todo')")
    public ResultUtil addTodo(@RequestBody Todo todo) {
        // 调用todoService的addTodo方法，将待办事项添加到系统中
        todoService.addTodo(todo);
        // 返回操作成功的ResultUtil对象，包含成功消息
        return ResultUtil.success("任务清单添加成功");
    }



    /**
     * 管理员更新待办事项
     *
     * 此方法接收一个Todo对象和一个todoId参数，通过todoId确定要更新的待办事项，
     * 然后使用接收到的Todo对象的数据来更新该待办事项。
     *
     * @param todo 包含待办事项新数据的Todo对象。
     * @param todoId 待更新的待办事项的ID。
     * @return 返回一个ResultUtil对象，表示操作结果，成功时包含成功消息。
     * @PreAuthorize 注解用于权限控制，确保调用者具有相应的更新权限。
     */
    @PostMapping("/updateTodo")
    @PreAuthorize("hasAuthority('sys:update:todo')")
    public ResultUtil updateTodo(@RequestBody Todo todo, Long todoId) {
        // 调用todoService的updateTodoById方法更新指定ID的待办事项。
        todoService.updateTodoById(todo, todoId);
        // 返回操作成功的ResultUtil对象，包含成功消息。
        return ResultUtil.success("任务清单修改成功");
    }


    /**
     * 管理员删除待办事项
     * @param todoId 待删除的待办事项的ID。
     * @return 返回一个ResultUtil对象，表示操作结果，成功时包含成功消息。
     */
    @PostMapping("/deleteTodo")
    @PreAuthorize("hasAuthority('sys:delete:todo')")
    public ResultUtil deleteTodo(Long todoId) {
        // 调用todoService的deleteTodoById方法删除指定ID的待办事项。
        todoService.deleteTodoById(todoId);
        // 返回操作成功的ResultUtil对象，包含成功消息。
        return ResultUtil.success("任务清单删除成功");
    }


    /**
     * 管理员查询所有todo待办事项
     * @return 返回一个ResultUtil对象，包含所有待办事项信息。
     */
    @GetMapping("/showAllTodo")
    @PreAuthorize("hasAuthority('sys:todo:list')")
    public ResultUtil showAllTodo() {
        // 调用todoService的getAllTodo方法获取所有待办事项信息。
        List<Todo> todoList = todoService.getAllTodo();
        // 返回一个ResultUtil对象，包含所有待办事项信息。
        return ResultUtil.success(todoList);

    }

    /**
     * 管理员添加待办事项。
     *
     * 此方法接收一个checklist对象作为请求体，用于新增待办事项。
     * 使用@PreAuthorize注解来指定只有具备'sys:add:checklist'权限的用户才能执行此操作。
     *
     * @param checklist 待添加的待办事项对象，包含待办事项的详细信息。
     * @return 返回一个ResultUtil对象，表示操作结果。
     *         如果操作成功，会包含一个成功消息。
     */
    @PostMapping("/addChecklist")
    @PreAuthorize("hasAuthority('sys:add:checklist')")
    public ResultUtil addTodo(@RequestBody Checklist checklist) {
        // 调用checkListService的addChecklist方法，将待办事项添加到系统中
        checkListService.addChecklist(checklist);
        // 返回操作成功的ResultUtil对象，包含成功消息
        return ResultUtil.success("待办添加成功");
    }


    /**
     * 管理员更新待办事项
     *
     * 此方法接收一个Checklist对象和一个checklistId参数，通过checklistId确定要更新的待办事项，
     * 然后使用接收到的Checklist对象的数据来更新该待办事项。
     *
     * @param checklist 包含待办事项新数据的Checklist对象。
     * @param checklistId 待更新的待办事项的ID。
     * @return 返回一个ResultUtil对象，表示操作结果，成功时包含成功消息。
     * @PreAuthorize 注解用于权限控制，确保调用者具有相应的更新权限。
     */
    @PostMapping("/updateChecklist")
    @PreAuthorize("hasAuthority('sys:update:checklist')")
    public ResultUtil updateChecklist(@RequestBody Checklist checklist, Long checklistId) {
        // 调用todoService的updateChecklistById方法更新指定ID的待办事项。
        checkListService.updateChecklistById(checklist, checklistId);
        // 返回操作成功的ResultUtil对象，包含成功消息。
        return ResultUtil.success("待办修改成功");
    }


    /**
     * 管理员删除待办事项
     * @param checklistId 待删除的待办事项的ID。
     * @return 返回一个ResultUtil对象，表示操作结果，成功时包含成功消息。
     */
    @PostMapping("/deleteChecklist")
    @PreAuthorize("hasAuthority('sys:delete:checklist')")
    public ResultUtil deleteChecklist(Long checklistId) {
        // 调用checklistService的deleteChecklistById方法删除指定ID的待办事项。
        checkListService.deleteChecklistById(checklistId);
        // 返回操作成功的ResultUtil对象，包含成功消息。
        return ResultUtil.success("待办删除成功");
    }


    /**
     * 管理员查询所有checklist待办事项
     * @return 返回一个ResultUtil对象，包含所有checklist待办事项信息。
     */
    @GetMapping("/showAllChecklist")
    @PreAuthorize("hasAuthority('sys:checklist:list')")
    public ResultUtil showAllChecklist() {
        // 调用checklistService的getAllTodo方法获取所有待办事项信息。
        List<Checklist> checklists = checkListService.getAllChecklist();
        // 返回一个ResultUtil对象，包含所有待办事项信息。
        return ResultUtil.success(checklists);
    }


    /**
     * 管理员添加倒数日
     * 此方法接收一个daysMatter对象作为请求体，用于新增倒数日。
     * 使用@PreAuthorize注解来指定只有具备'sys:add:daysMatter'权限的用户才能执行此操作。
     *
     * @param daysMatter 待添加的倒数日对象，包含倒数日的详细信息。
     * @return 返回一个ResultUtil对象，表示操作结果。
     *         如果操作成功，会包含一个成功消息。
     */
    @PostMapping("/addDaysMatter")
    @PreAuthorize("hasAuthority('sys:add:daysMatter')")
    public ResultUtil addDaysMatter(@RequestBody DaysMatter daysMatter) {
        // 调用daysMatterService的addDaysMatter方法，将倒数日添加到系统中
        daysMatterService.addDaysMatter(daysMatter);
        // 返回操作成功的ResultUtil对象，包含成功消息
        return ResultUtil.success("倒数日添加成功");
    }


    /**
     * 管理员更新倒数日
     *
     * 此方法接收一个DaysMatter对象和一个daysMatterId参数，通过daysMatterId确定要更新的倒数日，
     * 然后使用接收到的DaysMatter对象的数据来更新该倒数日。
     *
     * @param daysMatter 包含倒数日新数据的DaysMatter对象。
     * @param daysMatterId 待更新的倒数日的ID。
     * @return 返回一个ResultUtil对象，表示操作结果，成功时包含成功消息。
     * @PreAuthorize 注解用于权限控制，确保调用者具有相应的更新权限。
     */
    @PostMapping("/updateDaysMatter")
    @PreAuthorize("hasAuthority('sys:update:daysMatter')")
    public ResultUtil updateChecklist(@RequestBody DaysMatter daysMatter, Long daysMatterId) {
        // 调用todoService的updateDaysMatterById方法更新指定ID的倒数日。
        daysMatterService.updateDaysMatterById(daysMatter, daysMatterId);
        // 返回操作成功的ResultUtil对象，包含成功消息。
        return ResultUtil.success("倒数日修改成功");
    }


    /**
     * 管理员删除倒数日
     * @param daysMatterId 待删除的倒数日的ID。
     * @return 返回一个ResultUtil对象，表示操作结果，成功时包含成功消息。
     */
    @PostMapping("/deleteDaysMatter")
    @PreAuthorize("hasAuthority('sys:delete:daysMatter')")
    public ResultUtil deleteDaysMatter(Long daysMatterId) {
        // 调用daysMatterService的deleteDaysMatterById方法删除指定ID的倒数日。
        daysMatterService.deleteDaysMatterById(daysMatterId);
        // 返回操作成功的ResultUtil对象，包含成功消息。
        return ResultUtil.success("倒数日删除成功");
    }


    /**
     * 管理员查询所有daysMatter倒数日
     * @return 返回一个ResultUtil对象，包含所有checklist倒数日信息。
     */
    @GetMapping("/showAllDaysMatter")
    @PreAuthorize("hasAuthority('sys:daysMatter:list')")
    public ResultUtil showAllDaysMatter() {
        // 调用daysMatterService的getAllDaysMatter方法获取所倒数日信息。
        List<DaysMatter> daysMatters = daysMatterService.getAllDaysMatterlist();
        // 返回一个ResultUtil对象，包含所有倒数日信息。
        return ResultUtil.success(daysMatters);
    }



}
